package tui

import (
	"fmt"
	"strings"
	"time"

	"anders-cli/internal/ai"
	"anders-cli/internal/multiagent"
	"anders-cli/internal/tools"
	"anders-cli/pkg/logger"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

// 消息类型定义
type aiResponseMsg struct {
	content   string
	agentName string
}

type errorMsg struct {
	err error
}

func (e errorMsg) Error() string {
	if e.err != nil {
		return e.err.Error()
	}
	return "未知错误"
}

type loadingMsg struct {
	loading bool
}

// AIError AI相关错误
type AIError struct {
	message string
}

func (e *AIError) Error() string {
	return e.message
}

// Model 应用程序模型
type Model struct {
	// 界面状态
	width   int
	height  int
	input   string
	cursor  int
	focus   focus
	loading bool

	// 历史记录滚动
	historyOffset int // 历史记录的滚动偏移量
	historyHeight int // 历史区域的高度

	// 错误处理
	lastError  error
	errorCount int
	showError  bool

	// 性能监控
	performanceMonitor *PerformanceMonitor
	requestLimiter     *RequestLimiter
	connectionPool     *ConnectionPool

	// 模型选择
	showModelSelector bool     // 是否显示模型选择器
	modelCursor       int      // 模型选择器的光标位置
	availableModels   []string // 可用的模型列表

	// 数据
	history       []HistoryEntry
	aiBackend     ai.Backend
	multiAgentMgr *multiagent.MultiAgentManager
	toolCaller    *tools.ToolCaller

	// 多Agent进度跟踪
	lastTask       string
	lastResponse   string
	lastConfidence int
	lastFeedback   string

	// AI推理过程
	currentReasoning string // 当前推理过程
	showReasoning    bool   // 是否显示推理过程

	// Gantt图数据
	currentProject string          // 当前项目名称
	ganttTasks     []GanttTaskItem // Gantt图任务列表
	showGantt      bool            // 是否显示Gantt图

	// Gantt图缓存（性能优化）
	ganttCache       string // 缓存的Gantt图渲染结果
	ganttCacheWidth  int    // 缓存时的窗口宽度
	ganttCacheHeight int    // 缓存时的窗口高度
	ganttDirty       bool   // 标记缓存是否失效

	// 暂停功能
	isPaused        bool // 是否处于暂停状态
	pausePromptMode bool // 是否在暂停提示模式（等待用户输入）

	// 样式
	styles styles

	// 用户输入框专用样式
	inputBoxStyle lipgloss.Style
}

// HistoryEntry 历史记录条目
type HistoryEntry struct {
	Timestamp time.Time
	Role      string // "user" | "assistant" | "system"
	Content   string
	AgentName string // Agent名称（用于AI回复）
}

// GanttTaskItem Gantt图任务项
type GanttTaskItem struct {
	ID        string     // 任务ID
	Name      string     // 任务名称
	AgentRole string     // 负责的Agent角色
	Status    string     // 任务状态: pending, in_progress, completed, paused
	Progress  int        // 进度百分比 (0-100)
	StartTime time.Time  // 开始时间
	EndTime   *time.Time // 结束时间 (可为空)
	Phase     string     // 所属阶段: planning, execution, completion
}

// focus 焦点位置
type focus int

const (
	focusInput focus = iota
	focusHistory
)

// styles 定义所有样式
type styles struct {
	// 颜色方案 - 高对比度，护眼
	border     lipgloss.Style
	title      lipgloss.Style
	input      lipgloss.Style
	userMsg    lipgloss.Style
	aiMsg      lipgloss.Style
	systemMsg  lipgloss.Style
	errorMsg   lipgloss.Style
	loadingMsg lipgloss.Style
	help       lipgloss.Style
}

// NewModel 创建新的模型实例
func NewModel() *Model {
	// 创建AI后端
	backend, err := ai.NewBackend()
	if err != nil {
		logger.Error("创建AI后端失败: %v", err)
		backend = nil
	} else {
		logger.Info("TUI中创建后端成功: %s", backend.Name())
	}

	// 创建多Agent管理器
	var multiAgentMgr *multiagent.MultiAgentManager
	if backend != nil {
		multiAgentMgr, err = multiagent.NewMultiAgentManager()
		if err != nil {
			logger.Error("创建多Agent管理器失败: %v", err)
			multiAgentMgr = nil
		} else {
			logger.Info("多Agent管理器创建成功")
		}
	}

	// 初始化性能监控组件
	performanceMonitor := NewPerformanceMonitor()
	requestLimiter := NewRequestLimiter(100 * time.Millisecond) // 限制请求频率
	connectionPool := NewConnectionPool(10)                     // 连接池最大10个连接

	// 初始化可用模型列表
	availableModels := []string{
		"gemma3:4b (Ollama)",
		"openai/gpt-oss-20b (LMStudio)",
		"grok-4 (xAI)",
	}

	styles := createStyles()

	return &Model{
		focus:              focusInput,
		aiBackend:          backend,
		multiAgentMgr:      multiAgentMgr,
		toolCaller:         tools.NewToolCaller(),
		performanceMonitor: performanceMonitor,
		requestLimiter:     requestLimiter,
		connectionPool:     connectionPool,
		availableModels:    availableModels,
		styles:             styles,
		inputBoxStyle:      createInputBoxStyle(),

		// Gantt图初始化
		currentProject: "",
		ganttTasks:     []GanttTaskItem{},
		showGantt:      false,

		// Gantt图缓存初始化
		ganttCache:       "",
		ganttCacheWidth:  0,
		ganttCacheHeight: 0,
		ganttDirty:       true,

		// 暂停功能初始化
		isPaused:        false,
		pausePromptMode: false,

		// AI推理过程初始化
		currentReasoning: "",
		showReasoning:    false,

		history: []HistoryEntry{
			{
				Timestamp: time.Now(),
				Role:      "system",
				Content:   "欢迎使用 Anders CLI！输入您的消息或使用 /help 查看帮助。",
			},
		},
	}
}

// renderGantt 渲染Gantt图（仅在/team模式下显示）
func (m *Model) renderGantt() string {
	// 检查是否在/team模式
	if m.multiAgentMgr == nil || m.multiAgentMgr.GetCurrentMode() != "team" {
		return ""
	}

	if !m.showGantt || len(m.ganttTasks) == 0 {
		// 如果在/team模式但没有任务，显示占位符
		return m.styles.help.Render("📊 项目进度：等待任务分解...")
	}

	// 检查缓存是否有效
	if !m.ganttDirty && m.ganttCache != "" &&
		m.ganttCacheWidth == m.width && m.ganttCacheHeight == m.height {
		return m.ganttCache
	}

	// 重新渲染并缓存结果
	m.ganttDirty = false

	var sb strings.Builder
	sb.Grow(2048) // 预分配内存以提高性能

	// 根据窗口宽度调整标题长度
	maxTitleWidth := m.width - 10 // 留出边距
	if maxTitleWidth < 20 {
		maxTitleWidth = 20
	}

	projectName := m.currentProject
	if len(projectName) > maxTitleWidth-15 { // 15是"📊 项目进度 - "的长度
		projectName = projectName[:maxTitleWidth-18] + "..."
	}

	// Gantt图标题
	title := fmt.Sprintf("📊 项目进度 - %s", projectName)
	sb.WriteString(title)
	sb.WriteString("\n")
	sb.WriteString(strings.Repeat("─", len(title)))
	sb.WriteString("\n\n")

	// 按阶段分组任务
	phases := map[string][]GanttTaskItem{
		"planning":   {},
		"execution":  {},
		"completion": {},
	}

	for _, task := range m.ganttTasks {
		if tasks, exists := phases[task.Phase]; exists {
			phases[task.Phase] = append(tasks, task)
		} else {
			phases["execution"] = append(phases["execution"], task) // 默认归类到执行阶段
		}
	}

	// 渲染每个阶段
	phaseNames := map[string]string{
		"planning":   "📋 规划阶段",
		"execution":  "⚙️  执行阶段",
		"completion": "✅ 完成阶段",
	}

	for phase, tasks := range phases {
		if len(tasks) == 0 {
			continue
		}

		sb.WriteString(phaseNames[phase])
		sb.WriteString("\n")

		for _, task := range tasks {
			// 状态图标
			var statusIcon string
			switch task.Status {
			case "pending":
				statusIcon = "⏳"
			case "in_progress":
				statusIcon = "🔄"
			case "completed":
				statusIcon = "✅"
			case "paused":
				statusIcon = "⏸️"
			default:
				statusIcon = "❓"
			}

			// 进度条
			progressBar := m.renderProgressBar(task.Progress)

			// 根据窗口宽度调整任务名称长度
			maxTaskNameWidth := m.width - 40 // 预留空间给图标、进度条等
			if maxTaskNameWidth < 20 {
				maxTaskNameWidth = 20
			}

			taskName := task.Name
			if len(taskName) > maxTaskNameWidth {
				taskName = taskName[:maxTaskNameWidth-3] + "..."
			}

			agentRole := task.AgentRole
			if len(agentRole) > 15 {
				agentRole = agentRole[:12] + "..."
			}

			// 任务行
			taskLine := fmt.Sprintf("  %s %s (%s): [%s] %d%%",
				statusIcon, taskName, agentRole, progressBar, task.Progress)

			// 如果有结束时间，显示持续时间（只在窗口足够宽时显示）
			if task.EndTime != nil && m.width > 80 {
				duration := task.EndTime.Sub(task.StartTime)
				taskLine += fmt.Sprintf(" ⏱️ %v", duration.Round(time.Second))
			}

			sb.WriteString(taskLine)
			sb.WriteString("\n")
		}

		sb.WriteString("\n")
	}

	// 更新缓存
	result := sb.String()
	m.ganttCache = result
	m.ganttCacheWidth = m.width
	m.ganttCacheHeight = m.height

	return result
}

// renderProgressBar 渲染进度条
func (m *Model) renderProgressBar(progress int) string {
	// 根据窗口宽度动态调整进度条长度
	barWidth := 20
	if m.width > 100 {
		barWidth = 25
	} else if m.width < 80 {
		barWidth = 15
	}

	filled := progress * barWidth / 100
	if filled > barWidth {
		filled = barWidth
	}

	// 使用Unicode块字符，预分配内存
	var bar strings.Builder
	bar.Grow(barWidth)

	for i := 0; i < filled; i++ {
		bar.WriteString("█")
	}
	for i := filled; i < barWidth; i++ {
		bar.WriteString("░")
	}

	return bar.String()
}

// UpdateGanttTask 更新或添加Gantt任务
func (m *Model) UpdateGanttTask(taskID, name, agentRole, status string, progress int, phase string) {
	logger.Info("更新Gantt任务: %s (%s) - %s %d%%", taskID, name, status, progress)

	// 标记缓存失效
	m.ganttDirty = true

	// 查找现有任务
	for i, task := range m.ganttTasks {
		if task.ID == taskID {
			// 更新现有任务
			m.ganttTasks[i].Name = name
			m.ganttTasks[i].AgentRole = agentRole
			m.ganttTasks[i].Status = status
			m.ganttTasks[i].Progress = progress
			m.ganttTasks[i].Phase = phase

			// 如果任务完成，设置结束时间
			if status == "completed" && m.ganttTasks[i].EndTime == nil {
				endTime := time.Now()
				m.ganttTasks[i].EndTime = &endTime
			}

			logger.Info("Gantt任务更新成功: %s", taskID)
			return
		}
	}

	// 添加新任务
	newTask := GanttTaskItem{
		ID:        taskID,
		Name:      name,
		AgentRole: agentRole,
		Status:    status,
		Progress:  progress,
		StartTime: time.Now(),
		EndTime:   nil,
		Phase:     phase,
	}

	m.ganttTasks = append(m.ganttTasks, newTask)
	logger.Info("Gantt任务添加成功: %s", taskID)
}

// SetCurrentProject 设置当前项目
func (m *Model) SetCurrentProject(projectName string) {
	logger.Info("设置当前项目: %s", projectName)
	m.currentProject = projectName
	m.showGantt = true
	m.ganttDirty = true // 标记缓存失效
}

// ClearGanttTasks 清空Gantt任务
func (m *Model) ClearGanttTasks() {
	logger.Info("清空Gantt任务")
	m.ganttTasks = []GanttTaskItem{}
	m.currentProject = ""
	m.showGantt = false
	m.ganttDirty = true // 标记缓存失效
}

// GetGanttTaskCount 获取Gantt任务数量
func (m *Model) GetGanttTaskCount() int {
	return len(m.ganttTasks)
}

// createStyles 创建样式定义 - 高对比度护眼色彩方案
func createStyles() styles {
	// 优化后的色彩方案 - 保持系统背景黑色，强调输入框
	borderColor := lipgloss.Color("#44475A")  // 柔和的深灰
	titleColor := lipgloss.Color("#50FA7B")   // 亮绿色 - 标题
	inputColor := lipgloss.Color("#F8F8F2")   // 几乎白色 - 主要文字
	userColor := lipgloss.Color("#BD93F9")    // 亮紫色 - 用户消息
	aiColor := lipgloss.Color("#8BE9FD")      // 亮青色 - AI 消息
	systemColor := lipgloss.Color("#FFB86C")  // 橙色 - 系统消息
	errorColor := lipgloss.Color("#FF5555")   // 红色 - 错误
	loadingColor := lipgloss.Color("#F1FA8C") // 黄色 - 加载状态
	helpColor := lipgloss.Color("#6272A4")    // 柔和蓝色 - 帮助文字

	// 创建样式
	return styles{
		// 主边框样式 - 使用系统默认背景（黑色）
		border: lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(borderColor).
			Padding(0, 1),

		// 标题样式 - 粗体，亮绿色，居中
		title: lipgloss.NewStyle().
			Foreground(titleColor).
			Bold(true).
			Align(lipgloss.Center),

		// 输入框样式 - 普通文本样式（用于历史记录显示）
		input: lipgloss.NewStyle().
			Foreground(inputColor).
			Bold(true),

		// 用户消息样式 - 亮紫色，粗体
		userMsg: lipgloss.NewStyle().
			Foreground(userColor).
			Bold(true),

		// AI消息样式 - 亮青色
		aiMsg: lipgloss.NewStyle().
			Foreground(aiColor),

		// 系统消息样式 - 橙色，斜体
		systemMsg: lipgloss.NewStyle().
			Foreground(systemColor).
			Italic(true),

		// 错误消息样式 - 红色，粗体
		errorMsg: lipgloss.NewStyle().
			Foreground(errorColor).
			Bold(true).
			Background(lipgloss.Color("#2D1B1B")), // 深红背景突出错误

		// 加载状态样式 - 黄色，闪烁效果
		loadingMsg: lipgloss.NewStyle().
			Foreground(loadingColor).
			Bold(true),

		// 帮助文字样式 - 柔和蓝色，斜体
		help: lipgloss.NewStyle().
			Foreground(helpColor).
			Italic(true),
	}
}

// createInputBoxStyle 创建用户输入框专用样式 - 带白色边框
func createInputBoxStyle() lipgloss.Style {
	return lipgloss.NewStyle().
		Foreground(lipgloss.Color("#F8F8F2")). // 白色文字
		Border(lipgloss.RoundedBorder()).
		BorderForeground(lipgloss.Color("#FFFFFF")). // 白色边框
		Padding(0, 1).
		Bold(true)
}

// Init 初始化
func (m *Model) Init() tea.Cmd {
	return nil
}

// Update 处理消息更新
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		oldWidth, oldHeight := m.width, m.height
		m.width = msg.Width
		m.height = msg.Height

		// 如果窗口大小发生变化，标记Gantt缓存失效
		if oldWidth != m.width || oldHeight != m.height {
			m.ganttDirty = true
			logger.Debug("窗口大小变化: %dx%d -> %dx%d, Gantt缓存已失效",
				oldWidth, oldHeight, m.width, m.height)
		}

		return m, nil

	case tea.KeyMsg:
		return m.handleKeyMsg(msg)

	case aiResponseMsg:
		return m.handleAIResponse(msg)

	case errorMsg:
		m.handleError(msg.err)
		return m, nil

	case loadingMsg:
		m.loading = msg.loading
		return m, nil
	}

	return m, nil
}

// View 渲染界面
func (m *Model) View() string {
	if m.width == 0 || m.height == 0 {
		return "初始化中..."
	}

	// 如果显示模型选择器，使用不同的布局
	if m.showModelSelector {
		return m.renderModelSelector()
	}

	// 创建布局组件
	titleBar := m.renderTitle()
	ganttView := m.renderGantt()
	statusBar := m.renderStatusBar()
	historyView := m.renderHistory()
	inputView := m.renderInput()
	helpView := m.renderHelp()

	// 计算各部分高度
	titleHeight := lipgloss.Height(titleBar)
	ganttHeight := lipgloss.Height(ganttView)
	statusHeight := lipgloss.Height(statusBar)
	inputHeight := lipgloss.Height(inputView)
	helpHeight := lipgloss.Height(helpView)

	// 历史区域高度 = 总高度 - 其他所有部分
	historyHeight := m.height - titleHeight - ganttHeight - statusHeight - inputHeight - helpHeight - 2

	// 确保历史区域有最小高度
	if historyHeight < 3 {
		historyHeight = 3
	}

	// 设置历史区域高度（用于滚动计算）
	m.historyHeight = historyHeight

	// 应用样式和高度限制
	historyView = m.styles.border.
		Height(historyHeight).
		Width(m.width).
		Render(historyView)

	inputView = lipgloss.NewStyle().
		Width(m.width).
		Render(inputView)

	// 组合所有部分
	return lipgloss.JoinVertical(
		lipgloss.Top,
		titleBar,
		ganttView,
		statusBar,
		historyView,
		inputView,
		helpView,
	)
}

// renderTitle 渲染标题栏
func (m *Model) renderTitle() string {
	title := "🚀 Anders-CLI"
	if m.aiBackend != nil {
		// 显示后端名称，详细模型信息在状态栏显示
		title += " [" + m.aiBackend.Name() + "]"
	}

	// 显示当前模式
	if m.multiAgentMgr != nil {
		mode := m.multiAgentMgr.GetCurrentMode()
		if mode == "expert" {
			title += " [专家模式]"
		} else if mode == "team" {
			title += " [团队模式]"
		}
	}

	return m.styles.title.Width(m.width).Render(title)
}

// renderStatusBar 渲染状态栏
func (m *Model) renderStatusBar() string {
	// 构建状态信息
	statusParts := []string{}

	// AI 后端状态
	if m.aiBackend != nil {
		statusParts = append(statusParts, "🧠 "+m.aiBackend.GetModel())
	} else {
		statusParts = append(statusParts, "❌ 未连接")
	}

	// 历史记录数量
	statusParts = append(statusParts, fmt.Sprintf("📝 %d 条消息", len(m.history)))

	// 性能信息
	if m.performanceMonitor != nil {
		stats := m.performanceMonitor.GetStats()
		statusParts = append(statusParts, fmt.Sprintf("MEM %s", stats.FormatMemoryUsage()))
	}

	// 输入状态
	if m.loading {
		statusParts = append(statusParts, "⏳ AI 思考中...")
	} else if m.showError {
		statusParts = append(statusParts, "❌ 有错误")
	} else {
		statusParts = append(statusParts, "✏️ 准备输入")
	}

	// 错误计数（如果有错误）
	if m.errorCount > 0 {
		statusParts = append(statusParts, fmt.Sprintf("⚠️ %d 个错误", m.errorCount))
	}

	// 当前时间
	statusParts = append(statusParts, time.Now().Format("15:04:05"))

	// 组合状态信息
	statusText := strings.Join(statusParts, " | ")

	// 创建状态栏样式 - 移除背景色，使用系统默认
	statusStyle := lipgloss.NewStyle().
		Foreground(lipgloss.Color("#6272A4")).
		Padding(0, 1).
		Width(m.width)

	return statusStyle.Render(statusText)
}

// renderHistory 渲染历史记录
func (m *Model) renderHistory() string {
	var lines []string

	// 计算可见行数（减去边框等）
	contentWidth := m.width - 4 // 减去左右边框和内边距

	// 显示最近的历史记录
	maxLines := 1000 // 防止无限增长
	historyToShow := m.history
	if len(historyToShow) > maxLines {
		historyToShow = historyToShow[len(historyToShow)-maxLines:]
	}

	// 计算滚动范围
	totalHistoryLines := 0
	for _, entry := range historyToShow {
		contentLines := m.wrapText(entry.Content, contentWidth-20)
		totalHistoryLines += len(contentLines) + 1 // +1 for empty line between entries
	}

	// 调整滚动偏移量
	if m.historyOffset < 0 {
		m.historyOffset = 0
	}
	maxOffset := totalHistoryLines - m.historyHeight
	if maxOffset < 0 {
		maxOffset = 0
	}
	if m.historyOffset > maxOffset {
		m.historyOffset = maxOffset
	}

	// 渲染历史记录
	currentLine := 0
	for _, entry := range historyToShow {
		// 创建消息头部
		var prefix string
		var prefixStyle lipgloss.Style

		switch entry.Role {
		case "user":
			prefix = "👤 你"
			prefixStyle = m.styles.userMsg
		case "assistant":
			// 根据Agent信息决定显示名称
			if entry.AgentName != "" {
				prefix = "🤖 " + entry.AgentName
			} else {
				// 根据当前模式显示名称
				if m.multiAgentMgr != nil && m.multiAgentMgr.GetCurrentMode() == "expert" {
					prefix = "🤖 Victor (专家)"
				} else {
					prefix = "🤖 AI"
				}
			}
			prefixStyle = m.styles.aiMsg
		case "system":
			prefix = "💡 消息"
			prefixStyle = m.styles.systemMsg
		default:
			prefix = "❓ Unknown"
			prefixStyle = m.styles.help
		}

		// 格式化时间
		timeStr := entry.Timestamp.Format("15:04:05")
		timePrefix := m.styles.systemMsg.Render("[" + timeStr + "]")

		// 处理长消息的自动换行
		// 优化：减少前缀空间占用，让内容显示更多
		contentLines := m.wrapText(entry.Content, contentWidth-12) // 留出更少的空间给时间和前缀
		entryLines := len(contentLines) + 1                        // +1 for empty line

		// 检查是否在可见范围内
		if currentLine+entryLines <= m.historyOffset {
			currentLine += entryLines
			continue
		}

		// 第一行包含时间、前缀和内容
		if len(contentLines) > 0 {
			firstLine := lipgloss.JoinHorizontal(
				lipgloss.Left,
				timePrefix,
				" ",
				prefixStyle.Render(prefix+":"),
				" ",
				m.styles.input.Render(contentLines[0]),
			)

			// 只有在可见范围内才添加
			if currentLine >= m.historyOffset && len(lines) < m.historyHeight {
				lines = append(lines, firstLine)
			}
			currentLine++

			// 后续行只包含内容（缩进）
			for i := 1; i < len(contentLines); i++ {
				indentedLine := strings.Repeat(" ", 20) + m.styles.input.Render(contentLines[i])
				if currentLine >= m.historyOffset && len(lines) < m.historyHeight {
					lines = append(lines, indentedLine)
				}
				currentLine++
			}
		} else {
			// 空内容的情况
			line := lipgloss.JoinHorizontal(
				lipgloss.Left,
				timePrefix,
				" ",
				prefixStyle.Render(prefix+":"),
			)
			if currentLine >= m.historyOffset && len(lines) < m.historyHeight {
				lines = append(lines, line)
			}
			currentLine++
		}

		// 添加空行分隔
		if currentLine >= m.historyOffset && len(lines) < m.historyHeight {
			lines = append(lines, "")
		}
		currentLine++

		// 如果已经填满可见区域，停止渲染
		if len(lines) >= m.historyHeight {
			break
		}
	}

	// 如果正在加载，显示加载状态
	if m.loading {
		loadingText := m.styles.loadingMsg.Render("⏳ AI 正在思考中，请稍候...")
		lines = append(lines, "")
		lines = append(lines, strings.Repeat(" ", 10)+loadingText)
	}

	// 如果没有历史记录，显示欢迎信息
	if len(lines) == 0 {
		welcomeText := m.styles.help.Render("欢迎使用 Grok CLI！输入您的消息或使用 /help 查看帮助。")
		lines = append(lines, strings.Repeat(" ", 5)+welcomeText)
	}

	return strings.Join(lines, "\n")
}

// setError 设置错误状态
func (m *Model) setError(err error) {
	if err != nil {
		m.lastError = err
		m.errorCount++
		m.showError = true
		logger.Error("界面错误 #%d: %v", m.errorCount, err)

		// 添加用户友好的错误消息到历史记录
		friendlyMsg := m.getErrorMessage()
		m.addToHistory("system", m.styles.errorMsg.Render("❌ "+friendlyMsg))
	}
}

// clearError 清除错误状态
func (m *Model) clearError() {
	m.lastError = nil
	m.showError = false
}

// getErrorMessage 获取用户友好的错误消息
func (m *Model) getErrorMessage() string {
	if m.lastError == nil {
		return ""
	}

	var userFriendlyMsg string
	errMsg := m.lastError.Error()

	// 根据错误类型提供用户友好的消息
	switch {
	case strings.Contains(errMsg, "connection refused"):
		userFriendlyMsg = "无法连接到 AI 服务，请检查网络连接和服务状态"
	case strings.Contains(errMsg, "timeout") || strings.Contains(errMsg, "超时"):
		userFriendlyMsg = "当前模型超时无返回，请稍后重试"
	case strings.Contains(errMsg, "unauthorized"):
		userFriendlyMsg = "认证失败，请检查 API 密钥"
	case strings.Contains(errMsg, "file not found"):
		userFriendlyMsg = "文件不存在，请检查文件路径"
	case strings.Contains(errMsg, "permission denied"):
		userFriendlyMsg = "权限不足，无法访问文件"
	default:
		userFriendlyMsg = "发生未知错误: " + errMsg
	}

	return userFriendlyMsg
}

// handleError 处理并显示错误
func (m *Model) handleError(err error) {
	// 记录详细错误到日志
	logger.Error("界面处理错误: %v", err)

	// 显示用户友好的错误消息
	m.setError(err)
}

// addToHistory 添加消息到历史记录
func (m *Model) addToHistory(role, content string) {
	m.addToHistoryWithAgent(role, content, "")
}

// addToHistoryWithAgent 添加带Agent信息的消息到历史记录
func (m *Model) addToHistoryWithAgent(role, content, agentName string) {
	entry := HistoryEntry{
		Timestamp: time.Now(),
		Role:      role,
		Content:   content,
		AgentName: agentName,
	}
	m.history = append(m.history, entry)

	// 限制历史记录数量，防止内存泄漏
	maxHistory := 1000
	if len(m.history) > maxHistory {
		m.history = m.history[len(m.history)-maxHistory:]
	}

	// 更新性能监控数据
	if m.performanceMonitor != nil {
		m.performanceMonitor.UpdateMetrics(len(m.history), m.errorCount)
	}

	logger.Debug("添加历史记录: %s - %s", role, content[:min(50, len(content))])
}

// AddTestHistory 添加测试历史记录（用于测试UI效果）
func (m *Model) AddTestHistory(role, content string) {
	m.addToHistory(role, content)
}

// min 返回两个整数中的较小值
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// wrapText 将文本按指定宽度自动换行
func (m *Model) wrapText(text string, width int) []string {
	if width <= 0 {
		return []string{text}
	}

	// 如果文本很短，直接返回
	if len(text) <= width {
		return []string{text}
	}

	var lines []string
	words := strings.Fields(text)
	if len(words) == 0 {
		return []string{""}
	}

	currentLine := ""
	for _, word := range words {
		// 检查单词本身是否过长
		if len(word) > width {
			// 如果当前行不为空，先保存当前行
			if currentLine != "" {
				lines = append(lines, currentLine)
				currentLine = ""
			}
			// 对超长单词进行字符级换行
			lines = append(lines, m.wrapLongWord(word, width)...)
			continue
		}

		// 如果当前行加上新单词会超出宽度
		if len(currentLine)+len(word)+1 > width && currentLine != "" {
			lines = append(lines, currentLine)
			currentLine = word
		} else {
			if currentLine != "" {
				currentLine += " "
			}
			currentLine += word
		}
	}

	if currentLine != "" {
		lines = append(lines, currentLine)
	}

	return lines
}

// wrapLongWord 处理超长单词的换行
func (m *Model) wrapLongWord(word string, width int) []string {
	var lines []string
	for len(word) > width {
		lines = append(lines, word[:width])
		word = word[width:]
	}
	if word != "" {
		lines = append(lines, word)
	}
	return lines
}

// generateResponseSummary 生成响应摘要
func (m *Model) generateResponseSummary(response string, confidence int, feedback string) string {
	summary := "📋 响应摘要\n"

	// 添加置信度信息
	if confidence > 0 {
		summary += fmt.Sprintf("✅ 置信度: %d%%\n", confidence)
	}

	// 添加反馈信息
	if feedback != "" {
		summary += fmt.Sprintf("💬 反馈: %s\n", feedback)
	}

	// 估算响应长度和行数
	charCount := len(response)
	lines := strings.Count(response, "\n") + 1
	summary += fmt.Sprintf("📊 响应统计: %d 字符, 约 %d 行\n", charCount, lines)

	// 提取关键信息（前几行作为摘要）
	lines_slice := strings.Split(response, "\n")
	if len(lines_slice) > 0 {
		summary += "\n📝 内容预览:\n"
		previewLines := 3
		if len(lines_slice) < previewLines {
			previewLines = len(lines_slice)
		}

		for i := 0; i < previewLines; i++ {
			if lines_slice[i] != "" {
				// 截断过长的预览行
				preview := lines_slice[i]
				if len(preview) > 60 {
					preview = preview[:57] + "..."
				}
				summary += fmt.Sprintf("  %s\n", preview)
			}
		}
	}

	return summary
}

// renderInput 渲染输入框
func (m *Model) renderInput() string {
	var inputLine string
	prompt := "💬 "

	if m.focus == focusInput {
		// 显示光标（支持UTF-8）
		runes := []rune(m.input)
		cursorPos := m.cursor

		// 确保光标位置有效
		if cursorPos > len(runes) {
			cursorPos = len(runes)
		}

		// 在光标位置插入光标符号
		if cursorPos == 0 {
			inputLine = "█" + string(runes)
		} else {
			beforeCursor := string(runes[:cursorPos])
			afterCursor := string(runes[cursorPos:])
			inputLine = beforeCursor + "█" + afterCursor
		}
	} else {
		inputLine = m.input
	}

	// 组合提示符和输入内容
	fullInput := prompt + inputLine

	// 使用专门的输入框样式 - 带白色边框
	inputStyle := m.inputBoxStyle.Width(m.width - 4) // 减去边框宽度

	// 如果正在加载，修改样式但保持边框
	if m.loading {
		inputStyle = inputStyle.Foreground(lipgloss.Color("#6272A4"))
		thinkingText := "(AI 思考中...)"

		// 如果有推理过程，显示推理内容
		if m.showReasoning && m.currentReasoning != "" {
			// 显示推理过程的最后几行
			reasoningLines := strings.Split(m.currentReasoning, "\n")
			if len(reasoningLines) > 3 {
				reasoningLines = reasoningLines[len(reasoningLines)-3:]
			}
			reasoningText := strings.Join(reasoningLines, " ")
			if len(reasoningText) > 100 {
				reasoningText = reasoningText[:100] + "..."
			}
			thinkingText = fmt.Sprintf("(AI 推理中: %s)", reasoningText)
		}

		fullInput = prompt + m.styles.systemMsg.Render(thinkingText)
	}

	// 渲染输入框并居中显示
	inputBox := inputStyle.Render(fullInput)

	// 创建包装器以居中显示输入框
	wrapper := lipgloss.NewStyle().
		Width(m.width).
		Align(lipgloss.Center)

	return wrapper.Render(inputBox)
}

// renderHelp 渲染帮助信息
func (m *Model) renderHelp() string {
	helpItems := []string{
		"💬 输入消息",
		"⌨️ Tab: 自动补全",
		"⬅️➡️ 移动光标",
		"⏎ 发送消息",
		"🆘 Ctrl+C: 退出",
		"❓ /help: 帮助",
		"🚪 /quit: 退出",
		"📜 PgUp/PgDn: 滚动",
		"🧹 Ctrl+L: 清屏",
		"❌ Ctrl+E: 清错误",
	}

	// 根据终端宽度调整显示的项目数
	maxItems := (m.width - 4) / 15 // 每个项目大约15个字符
	if maxItems < 4 {
		maxItems = 4
	}
	if maxItems > len(helpItems) {
		maxItems = len(helpItems)
	}

	// 选择要显示的项目
	displayItems := helpItems[:maxItems]
	helpText := strings.Join(displayItems, " | ")

	// 创建帮助栏样式 - 移除背景色，使用系统默认
	helpStyle := lipgloss.NewStyle().
		Foreground(lipgloss.Color("#6272A4")).
		Padding(0, 1).
		Width(m.width)

	return helpStyle.Render(helpText)
}

// renderModelSelector 渲染模型选择器
func (m *Model) renderModelSelector() string {
	var lines []string

	// 标题
	title := m.styles.title.Width(m.width).Render("🤖 Anders-CLI - 选择AI模型")
	lines = append(lines, title)
	lines = append(lines, "")

	// 模型选项
	for i, model := range m.availableModels {
		var prefix string
		if i == m.modelCursor {
			prefix = m.styles.userMsg.Render("▶ ") // 高亮当前选择
		} else {
			prefix = "  "
		}

		line := prefix + model
		if i == m.modelCursor {
			line = m.styles.aiMsg.Render(line)
		} else {
			line = m.styles.input.Render(line)
		}
		lines = append(lines, line)
	}

	// 帮助信息
	lines = append(lines, "")
	helpText := m.styles.help.Render("↑↓: 选择模型 | Enter: 确认 | Esc: 取消")
	lines = append(lines, helpText)

	// 创建居中的对话框
	content := strings.Join(lines, "\n")
	boxWidth := 60
	if boxWidth > m.width-4 {
		boxWidth = m.width - 4
	}

	boxStyle := lipgloss.NewStyle().
		Border(lipgloss.RoundedBorder()).
		BorderForeground(lipgloss.Color("#50FA7B")).
		Padding(1, 2).
		Width(boxWidth).
		Align(lipgloss.Center)

	boxContent := boxStyle.Render(content)

	// 居中显示
	return lipgloss.Place(
		m.width, m.height,
		lipgloss.Center, lipgloss.Center,
		boxContent,
		lipgloss.WithWhitespaceChars("·"),
		lipgloss.WithWhitespaceForeground(lipgloss.Color("#6272A4")),
	)
}
